#!/usr/bin/env python3
import argparse
import re
import sys
from itertools import product

'''
    # 同步模式（默认）
    ./generator.py "process_{n}_{m}.log" \
    --var n 1 3 1 \
    --var m 5 7 1

    # 输出：
    process_1_5.log
    process_2_6.log
    process_3_7.log

'''

def parse_template_vars(template):
    """解析模板中的变量名"""
    pattern = re.compile(r'{([a-zA-Z_]\w*)(?:\:[^}]*)?}')
    return set(m.group(1) for m in pattern.finditer(template))

def generate_sequence(start, end, step):
    """生成数字序列并验证有效性"""
    if start > end:
        raise ValueError(f"起始值 {start} 不能大于结束值 {end}")
    if step <= 0:
        raise ValueError(f"无效步长 {step}")
    return list(range(start, end + 1, step))

def main():
    parser = argparse.ArgumentParser(description="多变量命令生成器")
    parser.add_argument("template", help="命令模板，使用 {变量名} 格式指定占位符")
    parser.add_argument("--var", action='append', nargs='+', metavar=('NAME', 'START', 'END', '[STEP]'),
                      help="变量配置，格式：变量名 起始值 结束值 [步长=1]")
    parser.add_argument("--mode", choices=['sync', 'product'], default='sync',
                      help="生成模式：sync-同步模式，product-笛卡尔积模式（默认：sync）")
    parser.add_argument("--dry-run", action='store_true', help="预览生成数量")

    args = parser.parse_args()

    # 解析模板变量
    template_vars = parse_template_vars(args.template)
    if not template_vars:
        print("错误：模板中未找到任何变量（使用 {变量名} 格式）")
        return sys.exit(1)

    # 解析变量配置
    variables = {}
    for var_config in args.var or []:
        try:
            name = var_config[0]
            start = int(var_config[1])
            end = int(var_config[2])
            step = int(var_config[3]) if len(var_config) > 3 else 1
            variables[name] = generate_sequence(start, end, step)
        except (IndexError, ValueError) as e:
            print(f"无效变量配置 '{' '.join(var_config)}': {e}")
            return sys.exit(1)

    # 检查未配置变量
    undefined_vars = template_vars - variables.keys()
    if undefined_vars:
        print(f"错误：未配置变量 {', '.join(undefined_vars)}")
        return sys.exit(1)

    # 生成变量组合
    if args.mode == 'sync':
        # 同步模式：所有变量序列长度必须相同
        lengths = {k: len(v) for k, v in variables.items()}
        if len(set(lengths.values())) > 1:
            print(f"错误：同步模式下变量长度不一致 {lengths}")
            return sys.exit(1)
        combinations = zip(*variables.values())
    else:
        # 笛卡尔积模式
        combinations = product(*variables.values())

    # 转换为可迭代列表
    combinations = list(combinations)
    
    if args.dry_run:
        print(f"将生成 {len(combinations)} 条命令")
        return

    # 生成命令
    for values in combinations:
        context = dict(zip(variables.keys(), values))
        try:
            print(args.template.format(**context))
        except KeyError as e:
            print(f"模板错误：未使用的变量 {e}")
            return sys.exit(1)
        except ValueError as e:
            print(f"格式错误：{e}")
            return sys.exit(1)

if __name__ == "__main__":
    main()